package com.example.tnot.api;

import io.socket.client.IO;
import io.socket.client.Socket;
import io.socket.emitter.Emitter;

import android.util.Base64;
import android.util.Log;
import org.json.JSONException;
import org.json.JSONObject;
import java.net.URISyntaxException;

public class SocketClient {
    private static final String TAG = "SocketClient";
    private static final String SERVER_URL = "http://10.30.3.223:8080";
    private Socket mSocket;
    // 新增：记录学生当前加入的房间ID
    private String studentCurrentRoomId;

    // 单例模式
    private static SocketClient instance;

    private SocketClient() {
        try {
            mSocket = IO.socket(SERVER_URL);
            setupSocketListeners();
        } catch (URISyntaxException e) {
            Log.e(TAG, "Socket初始化错误: " + e.getMessage());
        }
    }

    public static synchronized SocketClient getInstance() {
        if (instance == null) {
            instance = new SocketClient();
        }
        return instance;
    }

    // 设置Socket监听器（保留原有，新增学生端直播内容处理）
    private void setupSocketListeners() {
        mSocket.on(Socket.EVENT_CONNECT, new Emitter.Listener() {
            @Override
            public void call(Object... args) {
                Log.d(TAG, "已连接到服务器");
            }
        }).on("connection_ack", new Emitter.Listener() {
            @Override
            public void call(Object... args) {
                JSONObject data = (JSONObject) args[0];
                try {
                    String message = data.getString("message");
                    Log.d(TAG, "服务器响应: " + message);
                } catch (JSONException e) {
                    e.printStackTrace();
                }
            }
        }).on("receive_broadcast", new Emitter.Listener() {
            @Override
            public void call(Object... args) {
                JSONObject data = (JSONObject) args[0];
                try {
                    String message = data.getString("message");
                    Log.d(TAG, "收到广播消息: " + message);
                    if (messageListener != null) {
                        messageListener.onMessageReceived(message);
                    }
                } catch (JSONException e) {
                    e.printStackTrace();
                }
            }
        }).on(Socket.EVENT_DISCONNECT, new Emitter.Listener() {
            @Override
            public void call(Object... args) {
                Log.d(TAG, "与服务器断开连接");
            }
        }).on("error", new Emitter.Listener() {
            @Override
            public void call(Object... args) {
                JSONObject data = (JSONObject) args[0];
                try {
                    String errorMessage = data.getString("message");
                    Log.e(TAG, "收到错误信息: " + errorMessage);
                    if (errorListener != null) {
                        errorListener.onErrorReceived(errorMessage);
                    }
                } catch (JSONException e) {
                    e.printStackTrace();
                }
            }
        });

        // 教师端房间创建相关
        mSocket.on("live_room_created", args -> {
            JSONObject data = (JSONObject) args[0];
            try {
                String roomId = data.getString("room_id");
                Log.d("调用创建房间号","准备调用创建房间号");
                if (liveListener != null) {
                    liveListener.onLiveRoomCreated(roomId);
                } else {
                    Log.e("调用创建房间号","liveListener为空");
                }
            } catch (JSONException e) {
                e.printStackTrace();
                Log.e("SocketClient", "解析房间号失败", e);
            }
        });

        // 视频流数据（同时支持教师和学生，新增学生端判断）
        mSocket.on("live_stream_data", args -> {
            JSONObject data = (JSONObject) args[0];
            try {
                // 新增：获取数据所属房间ID
                String dataRoomId = data.getString("room_id");
                String frameBase64 = data.getString("frame_data");
                byte[] frameData = Base64.decode(frameBase64, Base64.NO_WRAP);

                // 教师端接收（原有逻辑保留）
                if (liveListener != null) {
                    liveListener.onLiveStreamData(frameData);
                }

                // 新增：学生端接收（仅当前加入的房间数据）
                if (studentLiveListener != null && dataRoomId.equals(studentCurrentRoomId)) {
                    studentLiveListener.onReceiveFrame(frameData);
                }
            } catch (JSONException e) {
                e.printStackTrace();
            }
        });

        // 直播错误（支持学生端）
        mSocket.on("live_error", args -> {
            JSONObject data = (JSONObject) args[0];
            try {
                String message = data.getString("message");
                // 教师端（原有）
                if (liveListener != null) {
                    liveListener.onLiveError(message);
                }
                // 新增：学生端错误回调
                if (studentLiveListener != null) {
                    studentLiveListener.onError(message);
                }
            } catch (JSONException e) {
                e.printStackTrace();
            }
        });

        // 观众数量变化（支持学生端显示）
        mSocket.on("live_viewer_joined", args -> {
            JSONObject data = (JSONObject) args[0];
            try {
                int count = data.getInt("count");
                String roomId = data.getString("room_id");
                // 教师端（原有）
                if (liveListener != null) {
                    liveListener.onViewerCountChanged(count);
                }
                // 新增：学生端接收当前房间的观众数量
                if (studentLiveListener != null && roomId.equals(studentCurrentRoomId)) {
                    studentLiveListener.onViewerCountChanged(count);
                }
            } catch (JSONException e) {
                e.printStackTrace();
            }
        });

        // 直播关闭（通知学生端）
        mSocket.on("live_room_closed", args -> {
            JSONObject data = (JSONObject) args[0];
            try {
                String roomId = data.getString("room_id");
                // 教师端（原有）
                if (liveListener != null) {
                    liveListener.onLiveRoomClosed();
                }
                // 新增：学生端收到房间关闭通知
                if (studentLiveListener != null && roomId.equals(studentCurrentRoomId)) {
                    studentLiveListener.onRoomClosed();
                    studentCurrentRoomId = null; // 清空当前房间
                }
            } catch (JSONException e) {
                e.printStackTrace();
            }
        });

        // 新增：学生端专属事件 - 房间状态更新（如直播开始/暂停）
        mSocket.on("room_status_update", args -> {
            JSONObject data = (JSONObject) args[0];
            try {
                String roomId = data.getString("room_id");
                String status = data.getString("status"); // "started", "paused", "ended"
                if (studentLiveListener != null && roomId.equals(studentCurrentRoomId)) {
                    studentLiveListener.onRoomStatusChanged(status);
                }
            } catch (JSONException e) {
                e.printStackTrace();
            }
        });
    }
    private boolean isConnecting = false;
    // 连接服务器（原有）
    public void connect() {
        if (mSocket != null && !mSocket.connected()  ) {
            mSocket.connect();

        }
    }

    // 断开连接（原有）
    public void disconnect() {
        if (mSocket != null && mSocket.connected()) {
            mSocket.disconnect();
            isConnecting=false;
            studentCurrentRoomId = null; // 断开时清空房间ID
        }
    }

    // 发送事件（原有）
    public void sendEmit(String socket,JSONObject data) {
        if(mSocket != null && mSocket.connected()) {
            mSocket.emit(socket, data);
        }
    }

    // 学生端连接（原有）
    public void studentConnect() {
        if (mSocket != null && mSocket.connected()) {
            mSocket.emit("student_connect");
        }
    }

    // 教师端连接（原有）
    public void teacherConnect() {
        Log.d("教师连接","尝试链接到教师");
        if (mSocket != null && mSocket.connected()) {
            mSocket.emit("teacher_connect");
            Log.d("教师连接","已连接到教师");
        }
    }

    // 监听连接状态（原有）
    public void listenConnect() {
        if (mSocket != null && mSocket.connected()) {
            mSocket.emit("listen_connect");
        }
    }

    // 发送广播消息（原有）
    public void sendBroadcast(String message) {
        if (mSocket != null && mSocket.connected() && message != null) {
            try {
                JSONObject data = new JSONObject();
                data.put("message", message);
                mSocket.emit("broadcast_message", data);
            } catch (JSONException e) {
                e.printStackTrace();
            }
        }
    }

    // 获取连接状态（原有）
    public boolean getmSocket() {
        return  mSocket.connected();
    }

    // 消息监听接口（原有）
    public interface OnMessageReceivedListener {
        void onMessageReceived(String message) throws JSONException;
    }

    private OnMessageReceivedListener messageListener;

    public void setOnMessageReceivedListener(OnMessageReceivedListener listener) {
        this.messageListener = listener;
    }

    // 错误信息监听接口（原有）
    public interface OnErrorReceivedListener {
        void onErrorReceived(String errorMessage);
    }

    private OnErrorReceivedListener errorListener;

    public void setOnErrorReceivedListener(OnErrorReceivedListener listener) {
        this.errorListener = listener;
    }

    // 教师端直播监听器（原有）
    private LiveStreamListener liveListener;

    public interface LiveStreamListener {
        void onLiveRoomCreated(String roomId);  // 房间创建成功
        void onLiveStreamData(byte[] frameData);  // 收到视频帧
        void onLiveError(String message);  // 直播错误
        void onViewerCountChanged(int count);  // 观众数量变化
        void onLiveRoomClosed();  // 直播关闭
    }

    public void setLiveListener(LiveStreamListener listener) {
        this.liveListener = listener;
    }

    // 新增：学生端直播专属监听器
    private StudentLiveListener studentLiveListener;

    public interface StudentLiveListener {
        void onReceiveFrame(byte[] frameData);  // 接收视频帧
        void onError(String message);  // 错误信息
        void onViewerCountChanged(int count);  // 观众数量变化
        void onRoomClosed();  // 房间关闭
        void onRoomStatusChanged(String status);  // 房间状态变化（开始/暂停等）
    }

    public void setStudentLiveListener(StudentLiveListener listener) {
        this.studentLiveListener = listener;
    }

    // 教师端创建房间（原有）
    public void createLiveRoom() {
        sendEmit("create_live_room", new JSONObject());
        Log.d("请求","创建房间请求已发送");
    }

    // 学生加入直播房间（原有，新增记录房间ID）
    public void joinLiveRoom(String roomId) {
        try {
            this.studentCurrentRoomId = roomId; // 记录学生当前房间
            JSONObject data = new JSONObject();
            data.put("room_id", roomId);
            sendEmit("join_live_room", data);
            Log.d(TAG, "学生加入房间: " + roomId);
        } catch (JSONException e) {
            e.printStackTrace();
        }
    }

    // 发送视频帧数据（教师用，原有）
    public void sendLiveFrame(String roomId, byte[] frameData) {
        try {
            JSONObject data = new JSONObject();
            data.put("room_id", roomId);
            data.put("frame_data", Base64.encodeToString(frameData, Base64.NO_WRAP));
            sendEmit("live_stream_data", data);
        } catch (JSONException e) {
            e.printStackTrace();
        }
    }

    // 离开直播房间（原有，新增清空学生房间ID）
    public void leaveLiveRoom(String roomId) {
        try {
            if (roomId.equals(studentCurrentRoomId)) {
                studentCurrentRoomId = null; // 离开时清空
            }
            JSONObject data = new JSONObject();
            data.put("room_id", roomId);
            sendEmit("leave_live_room", data);
        } catch (JSONException e) {
            e.printStackTrace();
        }
    }

    // 新增：获取学生当前所在房间ID
    public String getStudentCurrentRoomId() {
        return studentCurrentRoomId;
    }
}
